home *** CD-ROM | disk | FTP | other *** search
/ LiquidLibrary 2005 September / LiquidLibrary 2005 Sep - Disc 1.iso / pc / Portfolio Browser / Filters / PDF / LIB / gs_cidcm.ps < prev    next >
Text File  |  2003-01-03  |  18KB  |  487 lines
  1. %    Copyright (C) 2000 artofcode LLC.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile$ $Revision$
  7. % Extending Font resource category with CIDFont-CMap fonts.
  8.  
  9. languagelevel 2 .setlanguagelevel currentglobal true setglobal
  10.  
  11.  
  12. % In the comments below, 'CSI' is an abbreviation/acronym for CIDSystemInfo.
  13. % We pre-scan resource files to retrieve the CSI from them.
  14. % First we define a hidden procset .prs_dict containing
  15. % necessary variables and procedures.
  16. % Then we redefine the old /Font category using this procset.
  17.  
  18. % We maintain internal caches for the CSI values retrieved from
  19. % resource files. This supposes that document doesn't uninstall
  20. % resource files. To disable caching, set enable_cache to false.
  21.  
  22. % We suppose that names starting with '.prs' do not appear in resource files.
  23. % If this causes any problem, this prefix should be systematically changed
  24. % in this file.  ('prs' is an abbreviation for 'prescan'.)
  25.  
  26. 25 dict begin
  27.  
  28. % Define local variables :
  29.  
  30. /.prs_dict currentdict def       % self-reference (constant)
  31. /.prs_empty 0 dict readonly def  
  32. /path_buffer 255 string def
  33. /name_buffer 255 string def
  34. /minus (-) 0 get def             % character code constant for '-'
  35. /period (.) 0 get def            % character code constant for '.'
  36. /CMap 10 dict def                % CSI cache for CMaps
  37. /CIDFont 10 dict def             % CSI cache for CIDFonts
  38. /enable_cache true def           % set false to disable cache
  39.  
  40. % The folloving variables are just placeholders for ones to be set
  41. % dynamically :
  42. /.prsFile 0 def                   % file to prescan
  43. /.prsResult 0 def                 % result of prescan
  44. /.prsDictCount 0 def              % save the dictionary stack depth
  45.  
  46. % Define a dummy CIDInit procset to use while pre-scanning :
  47.  
  48. /DummyCIDInit 15 dict 
  49. begin
  50.  
  51.   /begincmap {} def
  52.   /usecmap {pop} bind def
  53.  
  54.   {stop} bind
  55.   [ /begincodespacerange /endcodespacerange /beginnotdefchar /endnotdefchar
  56.     /beginnotdefrange /endnotdefrange /begincidchar /endcidchar /begincidrange 
  57.     /endcidrange /endcmap /usefont /StartData
  58.   ] {
  59.     1 index def
  60.   } bind forall
  61.   pop
  62.  
  63. currentdict end def
  64.  
  65. % Define a local 'findresource' for pre-scanning :
  66. % (it returns the dummy CIDInit instead of the regular CIDInit ProcSet)
  67.  
  68. /findresource { % <InstName> <CatName> findresource <inst>
  69.   2 copy /ProcSet eq exch             % /InstName /CatName bool /InstName
  70.   /CIDInit eq and {
  71.     pop pop //DummyCIDInit
  72.   } {
  73.     //findresource exec
  74.   } ifelse
  75. } bind def
  76.  
  77. % Define procedures for pre-scanning :
  78.  
  79. /StopIfCSIDefined {   % - StopIfCSIDefined -
  80.   
  81.   % Check if the dictionary stack contains a dictionary containing /CIDSystemInfo. 
  82.   % The search is limited to the top .prsDictCount dictionaries in the stack.
  83.   % If so, retrieve the CSI, and execute stop to terminate the pre-scanning of the file.
  84.   % Otherwise, do nothing, so the pre-scanning continues.
  85.  
  86.   countdictstack //.prs_dict /.prsDictCount get sub dup {
  87.     currentdict /CIDSystemInfo .knownget {
  88.       //.prs_dict exch /.prsResult exch put
  89.       stop
  90.     } if
  91.     currentdict exch end
  92.   } repeat {
  93.     begin
  94.   } repeat
  95. } bind def
  96.  
  97. /PrescanFile {     % - PrescanFile -
  98.   { //.prs_dict /.prsFile get token {      
  99.       dup type                          % token type
  100.       dup /nametype eq exch /operatortype eq or {
  101.         dup xcheck {
  102.           exec
  103.           //StopIfCSIDefined exec
  104.         } if
  105.       } if
  106.     } {
  107.       stop
  108.     } ifelse
  109.   } loop
  110. } bind odef
  111.  
  112. /GetCIDSystemInfoFromFile { % <file> GetCIDSystemInfoFromFile <CSI>
  113.   
  114.   % This procedure reads resource files with 'token',
  115.   % executing the tokens untill /CIDSystemInfo appears to be defined.
  116.   % Normally the resource file creates a new dictionary on
  117.   % dictionary stack and defines /CIDSystemInfo in it.
  118.   %
  119.   % Returns an empty dictionary if no CIDSystemInfo is found.
  120.  
  121.   //.prs_dict begin
  122.   /.prsFile exch def
  123.   /.prsResult //.prs_empty def
  124.   /.prsDictCount countdictstack def
  125.   { //PrescanFile } stopped pop
  126.   //.prs_dict /.prsResult get
  127.   end
  128. } bind def
  129.  
  130. /GetCIDSystemInfo {     % <InstName> <CatName> GetCIDSystemInfo <CSI>
  131.   
  132.   % Retrieve CSI, using caches.
  133.   
  134.   2 copy resourcestatus {
  135.     pop 2 lt {
  136.       findresource /CIDSystemInfo .knownget not {
  137.         //.prs_empty
  138.       } if
  139.     } {                                                      
  140.       dup //.prs_dict exch get                % /InstName /CatName CSIs
  141.       dup 3 index known
  142.       //enable_cache and {                            
  143.         exch pop exch get                     % CSI
  144.       } {                                                  
  145.         3 1 roll                              % CSIs /InstName /CatName
  146.         /Category findresource begin          % CSIs /InstName
  147.         dup //path_buffer ResourceFileName    % CSIs /InstName (path)
  148.         end                                   
  149.         currentglobal exch true setglobal     % CSIs /InstName g
  150.         mark exch                             % CSIs /InstName g [ (path)
  151.         { (r) file                            % CSIs /InstName g [ file
  152.           //GetCIDSystemInfoFromFile exec     % CSIs /InstName g [ CSI
  153.         } stopped {
  154.           cleartomark //.prs_empty             
  155.         } {
  156.           exch pop
  157.         } ifelse                              % CSIs /InstName g CSI
  158.         exch setglobal                        % CSIs /InstName CSI
  159.         dup 4 1 roll                          % CSI CSIs /InstName CSI
  160.         put                                   % CSI
  161.       } ifelse
  162.     } ifelse
  163.   } {
  164.     pop pop //.prs_empty
  165.   } ifelse
  166. } bind def
  167.  
  168. /IsCompatibleCSI {  % <CSI-M> <CSI-F> IsCompatibleCSI <bool>
  169.   
  170.   % The CSI in a CIDFont may be an array, a dict, or null.
  171.   % If it is an array, it must be of 1 element, which is a dict.
  172.   % In this case the dict is used for testing the compatibility.
  173.   % Two dicts are compatible iff they contain same /Ordering and /Registry.
  174.  
  175.   exch                                  % CSI-F CSI-M
  176.   { dup type /arraytype eq {
  177.       dup length 1 ne {
  178.         pop pop false exit
  179.       } if
  180.       0 get
  181.     } if                                % CSI-F CSI-M
  182.     dup type /dicttype ne {
  183.       pop pop false exit
  184.     } if                                % CSI-F <<CSI-M>>
  185.     exch                                % <<CSI-M>> CSI-F
  186.     dup type /dicttype ne {
  187.       pop pop false exit
  188.     } if                                % <<CSI-M>> <<CSI-F>>
  189.     true                                % <<CSI-M>> <<CSI-F>> bEQ
  190.     [/Registry /Ordering] {                    
  191.       2 index 1 index .knownget not {
  192.         1234567
  193.       } if                              % <<CSI-M>> <<CSI-F>> bEQ /key vF
  194.       exch                              % <<CSI-M>> <<CSI-F>> bEQ vF /key
  195.       4 index exch .knownget not {
  196.         7654321
  197.       } if                              % <<CSI-M>> <<CSI-F>> bEQ vF vM
  198.       eq and                            % <<CSI-M>> <<CSI-F>> bEQ
  199.     } forall
  200.     exch pop exch pop                   % bEQ
  201.     exit
  202.   } loop
  203. } bind def
  204.  
  205. /IsComposedOK {     % <CIDFontName> <CMapName> IsComposedOK <bool>
  206.   
  207.   % Check if the given CIDFont and CMap have compatible CSIs.
  208.  
  209.   exch                                  % /CMapName /CIDFontName
  210.   /CIDFont //GetCIDSystemInfo exec      % /CMapName CSI-F
  211.   dup type /dicttype eq {
  212.     dup length 0 ne {                          
  213.       exch                              % CSI-F /CMapName
  214.       /CMap //GetCIDSystemInfo exec     % CSI-F CSI-M
  215.       //IsCompatibleCSI exec            % bool
  216.     } {
  217.       pop pop false
  218.     } ifelse
  219.   } {
  220.     pop pop false
  221.   } ifelse
  222. } bind def
  223.  
  224. /IsComposedFont {   % <FontName> IsComposedFont <CIDFontName> <CMapName> true
  225.                     % <FontName> IsComposedFont false
  226.   
  227.   % Check if the given font name may be decomposed into CIDFont.CMap, CIDFont-CMap
  228.   % or into CIDFont--CMap, such that CIDFont and CMap have compatible CSIs.
  229.                                         % FontName
  230.   dup type /stringtype ne {
  231.     //name_buffer cvs
  232.   } if                                  % (FontName)
  233.   { dup length 2 sub -1 1 {
  234.                                         % (FontName) i
  235.       2 copy get dup //minus eq exch //period eq or {                
  236.         2 copy 2 copy                   % (FontName) i (FontName) i (FontName) i
  237.         2 copy get //minus eq {
  238.           2 copy 1 sub get //minus eq {
  239.             1 sub
  240.           } if
  241.         } if                            % (FontName) i (FontName) i (FontName) i0
  242.         0 exch getinterval cvn          % (FontName) i (FontName) i /CIDFontName
  243.         3 1 roll                        % (FontName) i /CIDFontName (FontName) i
  244.         1 add dup                       % (FontName) i /CIDFontName (FontName) i1 i1
  245.         5 index length                  % (FontName) i /CIDFontName (FontName) i1 i1 l
  246.         exch sub getinterval cvn        % (FontName) i /CIDFontName /CMapName
  247.         2 copy //IsComposedOK exec {    % (FontName) i /CIDFontName /CMapName 
  248.           4 2 roll pop pop              % /CIDFontName /CMapName
  249.           stop
  250.         } if
  251.         pop pop pop
  252.       } {
  253.         pop
  254.       } ifelse                          % (FontName)
  255.     } for
  256.     pop
  257.   } stopped
  258. } bind def
  259.  
  260. /ComposeName { % <CIDFont> <CMap> <scr> ComposeName <CIDFont-CMap>
  261.   dup dup 5 2 roll                        % (scr) (scr) /CIDFont /CMap (scr)
  262.   3 2 roll exch cvs length dup            % (scr) (scr) /CMap l0 l0
  263.   4 -1 roll exch //minus put              % (scr) /CMap l0
  264.   1 add dup                               % (scr) /CMap l1 l1
  265.   3 index dup length                      % (scr) /CMap l1 l1 (scr) L
  266.   2 index sub                             % (scr) /CMap l1 l1 (scr) LT
  267.   3 2 roll                                % (scr) /CMap l1 (scr) LT l1
  268.   exch getinterval                        % (scr) /CMap l1 (scrT)
  269.   3 2 roll exch cvs length                % (scr) l1 l2
  270.   add 0 exch getinterval                  % (CIDFont-CMap)
  271. } bind def
  272.  
  273.  
  274. % Define a few procedure templates to be modified dynamically :
  275.  
  276. currentpacking false setpacking
  277.  
  278. /BindAux {   % <proc> BindAux <proc>
  279.   0 exec
  280. } bind def
  281.  
  282. /EnumerateFontNames { %  - EnumerateFontNames ...
  283.   
  284.   % This is a pattern for enumeration procedure to be built dynamically,
  285.   % using Bind with a temporary dictionary.
  286.   % The following names will be replaced with specific objects
  287.   % during Bind : en_local_dict, scr, proc, Fonts, Category .
  288.  
  289.   end % Category
  290.   { 
  291.     0 1 2 {
  292.       en_local_dict exch /status exch put
  293.       Fonts {                                            
  294.         en_local_dict /status get eq {            
  295.           scr cvs                           % ... (Font)
  296.           proc exec                         %
  297.         } {
  298.           pop
  299.         } ifelse                            % ...
  300.       } forall
  301.     } for                                   % ...
  302.   } stopped
  303.   Category begin
  304.   { stop } if
  305. } bind def
  306.  
  307. setpacking
  308.  
  309. /Bind {    % <proc> Bind <proc>
  310.   
  311.   % Make a copy of the given procedure, binding in the values of all names
  312.   % defined in currentdict.
  313.   % Caution : this code cannot handle procedures that were already
  314.   % bound recursively.
  315.  
  316.   dup length array copy
  317.   dup length 1 sub -1 0 {                      
  318.     2 copy get                            % {precopy} i {elem}
  319.     dup dup type /arraytype eq exch xcheck and {
  320.                                           % {precopy} i {elem}
  321.       //BindAux exec                      % {precopy} i {elem_copy}
  322.       2 index 3 1 roll put                % {precopy}
  323.     } {
  324.       dup dup type /nametype eq exch xcheck and {
  325.                                           % {precopy} i {elem}
  326.         currentdict exch .knownget {            
  327.           2 index 3 1 roll put            % {precopy}
  328.         } {                                            
  329.           pop
  330.         } ifelse
  331.       } {
  332.         pop pop
  333.       } ifelse
  334.     } ifelse                              % {precopy}
  335.   } for                                   % {copy}
  336.   cvx
  337. } bind def
  338.  
  339. //BindAux 0 //Bind put   % bind the recursive call in 'Bind'.
  340.  
  341.  
  342.  
  343. % Redefine the /Font category with CIDFont-CMap construction :
  344.  
  345. % The following code supposes that the following names are not
  346. % defined in the old /Font category dictionary :
  347. % /IsComposedFont, /Bind, /IsComposedOK, /EnumerateFontNames .
  348.  
  349.  
  350. /Font /Category findresource dup length dict copy begin
  351.  
  352. /FindResource {  % <InstName> FindResource <inst>
  353.   dup //ResourceStatus exec {
  354.     pop pop //FindResource exec
  355.   } {                                                
  356.     dup //IsComposedFont exec {          % /FontName /CIDFontName /CMapName 
  357.       exch [ exch ] composefont          % inst
  358.     } {
  359.       //FindResource exec
  360.     } ifelse
  361.   } ifelse
  362. } bind def
  363.  
  364. /ResourceStatus {  % <InstName> ResourceStatus <nStatus> <nSize> true
  365.                    % <InstName> ResourceStatus false
  366.   dup //ResourceStatus exec {                    
  367.     3 2 roll pop true                     % nStatus nSize true
  368.   } {                                                  
  369.     //IsComposedFont exec {               % /CIDFontName /CMapName 
  370.       /CMap resourcestatus {              % /CIDFontName nStatusM nSizeM 
  371.         exch pop exch                     % nSizeM /CIDFontName 
  372.         /CIDFont resourcestatus {         % nSizeM nStatusF nSizeF 
  373.           exch pop                        % nSizeF nSizeM
  374.           dup 0 ge {
  375.             exch dup 0 ge {
  376.               add
  377.             } {
  378.               exch pop
  379.             } ifelse
  380.           } {
  381.             pop
  382.           } ifelse                        % nSize
  383.           2 exch true                     % nStatus nSize true
  384.         } {                        
  385.           pop pop pop false  % work around buggy resource file
  386.         } ifelse
  387.       } {                            
  388.         pop pop pop false    % work around buggy resource file
  389.       } ifelse
  390.     } {
  391.       false
  392.     } ifelse
  393.   } ifelse
  394. } bind def
  395.  
  396. /ResourceForAll { % <template> <proc> <scratch> ResourceForAll - 
  397.  
  398.   % We suppose that the resourceforall procedure does not 
  399.   % define or install new fonts, CMaps, and/or CIDFonts.
  400.  
  401.   % First we create 3 temporary dictionaries to store temporary data
  402.   % about fonts, CMaps and CIDFonts.
  403.   % These dictionaries must be created dynamically, to allow for a possible 
  404.   % recursive call to resourceforall from the resourceforall procedure.
  405.  
  406.   currentglobal false setglobal
  407.   20 dict 20 dict 20 dict
  408.   4 -1 roll setglobal                     % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  409.  
  410.   % Store resource names into local dictionaries :
  411.  
  412.   5 index [ 2 index {exch cvn dup put} aload pop ] cvx 5 index //ResourceForAll exec
  413.   (*)     [ 3 index {exch cvn dup put} aload pop ] cvx 5 index /CMap resourceforall
  414.   (*)     [ 4 index {exch cvn dup put} aload pop ] cvx 5 index /CIDFont resourceforall
  415.  
  416.   %% Make the list of fonts in the form (/Name status) :
  417.  
  418.                                           % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  419.   dup {                                              
  420.     //ResourceStatus exec {                        
  421.       pop 2 index                         % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>> /Name nStatus <<Font>>
  422.       3 1 roll put                        % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  423.     } {
  424.       pop
  425.     } ifelse
  426.   } forall                                % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  427.  
  428.   %% Add CIDFont-CMap to it (filtering duplicates) :
  429.  
  430.   3 2 roll  {                                        
  431.     3 index {                                        
  432.       3 1 roll                            % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /CIDFont /CMap
  433.       6 index //ComposeName exec          % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap (Font)
  434.       dup 8 index .stringmatch {              
  435.         cvn                               % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /Font
  436.         dup 4 index exch known {
  437.           pop pop
  438.         } {                                            
  439.           2 index                         % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /Font /CIDFont
  440.           4 2 roll                        % (templ) proc (scr) <<CMap>> <<Font>> /Font /CIDFont /CIDFont /CMap
  441.           //IsComposedOK exec {                
  442.             exch 2 index exch 2 put       % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont
  443.           } {
  444.             exch pop
  445.           } ifelse
  446.         } ifelse
  447.       } {
  448.         pop pop
  449.       } ifelse
  450.       dup                                 % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CIDFont
  451.     } forall
  452.     pop pop                               % (templ) proc (scr) <<CMap>> <<Font>>
  453.   } forall                                % (templ) proc (scr) <<CMap>> <<Font>>
  454.   exch pop                                % (templ) proc (scr) <<Font>>
  455.  
  456.   % Build the enumeration procedure :
  457.  
  458.   % Since the resourceforall procedure may leave values on the operand stack,
  459.   % we cannot simply store the enumerator's local data on the stack.
  460.   % We also cannot use a static dictionary to store local variables,
  461.   % because of possible recursion in the resourceforall procedure.
  462.   % To work around this, we create a copy of the enumeration procedure and
  463.   % bind it dynamically with a temporary dictionary, which contains
  464.   % local variables for the currently executing instance of resourceforall.
  465.  
  466.   currentdict
  467.   6 dict begin % the temporary dictionary
  468.     /Category exch def
  469.     /Fonts exch def
  470.     /scr exch def
  471.     /proc exch def
  472.     /en_local_dict currentdict def
  473.     //EnumerateFontNames //Bind exec      % (templ) Enumerator
  474.     /status 0 def % variable for the current status to enumerate - do not Bind with it !
  475.   end
  476.   exch pop                                % Enumerator
  477.  
  478.   % Do the enumeration :
  479.  
  480.   exec
  481. } bind def
  482.  
  483.  
  484. currentdict end /Font exch /Category defineresource pop
  485. end
  486. setglobal .setlanguagelevel
  487.